{ "cells": [ { "cell_type": "markdown", "id": "c51e8572", "metadata": {}, "source": [ "# Homework 3\n", "\n", "In this homework you will:\n", "* Implement the Naive Bayes algorithm and use it for classification\n", "* Use feature weights learned with logistic regression to assess feature importance" ] }, { "cell_type": "markdown", "id": "3fe0cca2", "metadata": {}, "source": [ "## Naive Bayes\n", "\n", "Recall that the Naive Bayes classifier computes $p(\\textrm{class} = y|x)$ for an instance where $x = (x_1 = v_1, x_2 = v_2, \\ldots, x_n = v_n)$ is a vector of feature values. It does that for every possible value of the class label and chooses the label that yields the largest probability. Concretely, that probability is computed as follows (note the use of the \"proportional to\" symbol $\\propto$ below) because we are ignoring the $p(x)$ term that arised from Bayes rule).\n", "\n", "$p(class = y|x) \\propto p(x_1 = v_1 | class = y) * \n", "p(x_2 = v_2 | class = y) *\n", "\\ldots p(x_n = v_n | class = y) * p(class = y)$\n", "\n", "Below you will implement the Naive Bayes classifier (with lots of supporting routines already provided) and apply it to a dataset of mushrooms where the class label is 'p' for poisonous and 'e' for edible." ] }, { "cell_type": "code", "execution_count": 16, "id": "b367eb96", "metadata": {}, "outputs": [], "source": [ "import pandas as pd" ] }, { "cell_type": "markdown", "id": "da040cf2", "metadata": {}, "source": [ "### Load the data" ] }, { "cell_type": "code", "execution_count": 17, "id": "c5e03fb2", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
classcap-shapecap-surfacecap-colorbruisesodorgill-attachmentgill-spacinggill-sizegill-color...stalk-surface-below-ringstalk-color-above-ringstalk-color-below-ringveil-typeveil-colorring-numberring-typespore-print-colorpopulationhabitat
0pxsntpfcnk...swwpwopksu
1exsytafcbk...swwpwopnng
2ebswtlfcbn...swwpwopnnm
3pxywtpfcnn...swwpwopksu
4exsgfnfwbk...swwpwoenag
\n", "

5 rows × 23 columns

\n", "
" ], "text/plain": [ " class cap-shape cap-surface cap-color bruises odor gill-attachment \\\n", "0 p x s n t p f \n", "1 e x s y t a f \n", "2 e b s w t l f \n", "3 p x y w t p f \n", "4 e x s g f n f \n", "\n", " gill-spacing gill-size gill-color ... stalk-surface-below-ring \\\n", "0 c n k ... s \n", "1 c b k ... s \n", "2 c b n ... s \n", "3 c n n ... s \n", "4 w b k ... s \n", "\n", " stalk-color-above-ring stalk-color-below-ring veil-type veil-color \\\n", "0 w w p w \n", "1 w w p w \n", "2 w w p w \n", "3 w w p w \n", "4 w w p w \n", "\n", " ring-number ring-type spore-print-color population habitat \n", "0 o p k s u \n", "1 o p n n g \n", "2 o p n n m \n", "3 o p k s u \n", "4 o e n a g \n", "\n", "[5 rows x 23 columns]" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = pd.read_csv('mushrooms.csv')\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 18, "id": "ab6b17be", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['cap-shape',\n", " 'cap-surface',\n", " 'cap-color',\n", " 'bruises',\n", " 'odor',\n", " 'gill-attachment',\n", " 'gill-spacing',\n", " 'gill-size',\n", " 'gill-color',\n", " 'stalk-shape',\n", " 'stalk-root',\n", " 'stalk-surface-above-ring',\n", " 'stalk-surface-below-ring',\n", " 'stalk-color-above-ring',\n", " 'stalk-color-below-ring',\n", " 'veil-type',\n", " 'veil-color',\n", " 'ring-number',\n", " 'ring-type',\n", " 'spore-print-color',\n", " 'population',\n", " 'habitat']" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Names of features\n", "FEAT_NAMES = df.columns.to_list()[1:]\n", "FEAT_NAMES" ] }, { "cell_type": "code", "execution_count": 19, "id": "c6606286", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['p', 'e']" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Values for the class labels\n", "LABELS = ['p', 'e']\n", "LABELS" ] }, { "cell_type": "markdown", "id": "e5911a1d", "metadata": {}, "source": [ "### Counting\n", "\n", "The routine below does counting for you. Given a dataframe with mushroom instances, it can return 3 kinds of counts:\n", "* Counts of rows with a given class label\n", "* Counts of rows with a given feature value\n", "* Counts of rows with a given class label and a given feature value\n", "\n", "You can use this routine when computing the probabilities used by NB.\n", "\n", "Read through the code below, and then look at the cells after it to see examples of how to get each of the count types listed above.\n", "\n", "NOTE: I using memoization to store counts so they don't have to be computed from the raw data if that are requested a second time. That's irrelevant to what you need to do. It's just a simple way to avoid repeated work and will make your code significantly faster." ] }, { "cell_type": "code", "execution_count": 20, "id": "fef878f5", "metadata": {}, "outputs": [], "source": [ "MEMO = {}\n", "\n", "def count_rows(df, y = None, feat_name = None, feat_value = None):\n", " \n", " assert y is not None or feat_name is not None, \"You must specify at least a class or feature\"\n", " assert (feat_name is None and feat_value is None) or (feat_name is not None and feat_value is not None), \"Feature names require feature values, and vice versa\"\n", " \n", " key = None\n", " \n", " if y is not None and feat_name is None:\n", " key = 'class=%s' % y\n", " if not key in MEMO:\n", " MEMO[key] = len(df[df['class'] == y])\n", " \n", " if y is not None and feat_name is not None:\n", " key = 'class=%s;%s=%s' % (y, feat_name, feat_value)\n", " if not key in MEMO:\n", " MEMO[key] = len(df[(df['class'] == y) & (df[feat_name] == feat_value)])\n", "\n", " if y is None and feat_name is not None:\n", " key = '%s=%s' % (feat_name, feat_value)\n", " if not key in MEMO:\n", " MEMO[key] = len(df[df[feat_name] == feat_value])\n", "\n", " if key:\n", " return MEMO[key]\n", " \n", " assert True, \"Unexpected error\"\n", " " ] }, { "cell_type": "code", "execution_count": 21, "id": "ddf51b33", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3916" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Count the number of rows with class label 'p'\n", "count_rows(df, y = 'p')" ] }, { "cell_type": "code", "execution_count": 22, "id": "8079ee57", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2556" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Count the number of rows for which the cap-surface feature has the value 's'\n", "count_rows(df, feat_name = 'cap-surface', feat_value = 's')" ] }, { "cell_type": "code", "execution_count": 23, "id": "2a65748d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1412" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Count the number of rows for which the class label is 'p' and \n", "# the cap-surface feature has the value 's'\n", "count_rows(df, y = 'p', feat_name = 'cap-surface', feat_value = 's')" ] }, { "cell_type": "code", "execution_count": 24, "id": "e1fc7d1d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.36\n" ] } ], "source": [ "# Compute p(cap-surface = 's' | class = 'p')\n", "print('%.2f' % (count_rows(df, y = 'p', feat_name = 'cap-surface', feat_value = 's')/count_rows(df, y = 'p')))" ] }, { "cell_type": "markdown", "id": "2df449fc", "metadata": {}, "source": [ "### Split the data into training and testing sets" ] }, { "cell_type": "code", "execution_count": 25, "id": "4237f992", "metadata": {}, "outputs": [], "source": [ "df_train = df[:-1000]\n", "df_test = df[-1000:]" ] }, { "cell_type": "markdown", "id": "81c77de8", "metadata": {}, "source": [ "### How to access features and the class label\n", "\n", "The code below shows how to get the feature names/values for a test instance as well as the true class label.\n", "\n", "The syntax 
df_test.iloc[idx]
returns the row in the test dataframe at position idx. Valid positions run from 0 to len(df_test) - 1." ] }, { "cell_type": "code", "execution_count": 26, "id": "1340c6a5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test instance 10 has class = e\n", "\n", "Test instance 10 has cap-shape = k\n", "Test instance 10 has cap-surface = s\n", "Test instance 10 has cap-color = g\n", "Test instance 10 has bruises = f\n", "Test instance 10 has odor = n\n", "Test instance 10 has gill-attachment = f\n", "Test instance 10 has gill-spacing = w\n", "Test instance 10 has gill-size = b\n", "Test instance 10 has gill-color = p\n", "Test instance 10 has stalk-shape = e\n", "Test instance 10 has stalk-root = ?\n", "Test instance 10 has stalk-surface-above-ring = k\n", "Test instance 10 has stalk-surface-below-ring = k\n", "Test instance 10 has stalk-color-above-ring = w\n", "Test instance 10 has stalk-color-below-ring = w\n", "Test instance 10 has veil-type = p\n", "Test instance 10 has veil-color = w\n", "Test instance 10 has ring-number = t\n", "Test instance 10 has ring-type = p\n", "Test instance 10 has spore-print-color = w\n", "Test instance 10 has population = s\n", "Test instance 10 has habitat = g\n" ] } ], "source": [ "idx = 10\n", "print('Test instance %d has class = %s\\n' % (idx, df_test.iloc[idx]['class']))\n", "for feat_name in FEAT_NAMES:\n", " feat_value = df_test.iloc[idx][feat_name]\n", " print('Test instance %d has %s = %s' % (idx, feat_name, feat_value))" ] }, { "cell_type": "markdown", "id": "370e9441", "metadata": {}, "source": [ "# Task 1 - Implement Naive Bayes\n", "\n", "Fill in the function below. It takes as input the training set and an instance from the test set (e.g., df_test.iloc[10]) and returns the probabilities of the two classes. I store them in dictionaries, as you can see at the top of my partial implementation. But you can do whatever you want. Note that I initialize them to 1. Think about why I did that. Use count_rows() to get the quantities you need to classify the instance. To make a prediction you will simply choose the probability with the largest value.\n", "\n", "To help debug I've given the probabilities (they are normalized to sum to 1) that I got from my routine for a few test instances." ] }, { "cell_type": "code", "execution_count": 12, "id": "21b852fd", "metadata": {}, "outputs": [], "source": [ "def NB_probs(df_train, instance):\n", " probs = {'p':1, 'e':1}\n", " \n", " # YOUR CODE GOES HERE\n", " \n", " return probs" ] }, { "cell_type": "code", "execution_count": 13, "id": "fbf0653b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'p': 0.6102078440663387, 'e': 0.38979215593366134}\n", "{'p': 1.0, 'e': 0.0}\n", "{'p': 0.37969627358365715, 'e': 0.6203037264163429}\n" ] } ], "source": [ "# Sample output\n", "print(NB_probs(df_train, df_test.iloc[10]))\n", "print(NB_probs(df_train, df_test.iloc[100]))\n", "print(NB_probs(df_train, df_test.iloc[502]))" ] }, { "cell_type": "markdown", "id": "436237c7", "metadata": {}, "source": [ "# Task 2 - Use NB_probs() to classify \n", "\n", "Write code in the cell below to walk over the test data and classify each instance. **Print the classification accuracy at the end. Also print the index of each instance that is misclassified.** There is a little skeleton code to get you started." ] }, { "cell_type": "code", "execution_count": 27, "id": "a13bb01e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0\n" ] } ], "source": [ "num_correct = 0\n", "for idx in range(len(df_test)):\n", " pass\n", "print(num_correct/len(df_test))" ] }, { "cell_type": "markdown", "id": "8af82cbc", "metadata": {}, "source": [ "## Logistic Regression\n", "\n", "Recall that logistic regression learns a weight vector such that $wx >> 0$ for positive instances and $wx << 0$ for negative instances. Below you'll look at the weights that were learned and think about which features are important." ] }, { "cell_type": "code", "execution_count": 28, "id": "c640ca7b", "metadata": {}, "outputs": [], "source": [ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.datasets import load_wine\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from sklearn.metrics import accuracy_score" ] }, { "cell_type": "markdown", "id": "eed522fc", "metadata": {}, "source": [ "### Load the data\n", "\n", "The wine dataset has 13 features that are real valued and **all positive**. That last bit is important for what follows. The goal is to classify a sample of wine characterized by its 13 featues into one of three types of wines." ] }, { "cell_type": "code", "execution_count": 29, "id": "3b4938e1", "metadata": {}, "outputs": [], "source": [ "data = load_wine()\n", "X = data['data']\n", "y = data['target']" ] }, { "cell_type": "markdown", "id": "86f1ddfd", "metadata": {}, "source": [ "### Train a classifier and look at the feature weights\n", "\n", "The plot below shows the weights associated with all 13 features for each of the three classes. The are overlaid so that you can compare weights across classes." ] }, { "cell_type": "code", "execution_count": 30, "id": "64bdb2c8", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/oates/tmp/env/anaconda3/lib/python3.8/site-packages/sklearn/linear_model/_logistic.py:763: ConvergenceWarning: lbfgs failed to converge (status=1):\n", "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", "\n", "Increase the number of iterations (max_iter) or scale the data as shown in:\n", " https://scikit-learn.org/stable/modules/preprocessing.html\n", "Please also refer to the documentation for alternative solver options:\n", " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", " n_iter_i = _check_optimize_result(\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "clf = LogisticRegression(C = 1)\n", "clf.fit(X, y)\n", "x = list(range(13))\n", "plt.plot(x, clf.coef_[0], label=data['target_names'][0])\n", "plt.plot(x, clf.coef_[1], label=data['target_names'][1])\n", "plt.plot(x, clf.coef_[2], label=data['target_names'][2])\n", "plt.legend()\n", "plt.xticks(x, data['feature_names'], rotation ='vertical')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "6acfcd3f", "metadata": {}, "source": [ "# Task 3 - Answer the following questions\n", "\n", "Given the plot above, give a brief answer (a few sentences to a paragraph) to each of the following questions.\n", "\n", "* Which feature is most important for determining if a sample is class 1?\n", "* Which feature is most important for determining if a sample is class 2?\n", "* If malic_acid is a large number, does that make it more or less likely that the instance belongs to class 1? Why?\n", "* Which two classes are probably the hardest to tell apart? Why?\n", "* If you could only keep two features, which ones would you keep to maximize classification accuracy? Why those two?" ] }, { "cell_type": "code", "execution_count": null, "id": "9339cd55", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.8" } }, "nbformat": 4, "nbformat_minor": 5 }